#include<algorithm>

template<typename Object>
class Vector
{
public:
    //构造函数的实现，生成一个模板类的数组大小由实际大小与空余长度共同决定
    explicit Vector(int initSize = 0): theSize{initSize},
	theCapacity{ initSize + SPARE_CAPACITY }
	{ objects = new Object[ theCapacity ]; }
//复制构造函数的实现，构造新的内存空间，将大小与内容全部复制即可。
	
Vector( const Vector & rhs ) : theSize{ rhs.theSize },
	    theCapacity{ rhs.theCapacity }, objects{nullptr}
	    {
		objects = new Object[ theCapacity ];
		for(int k = 0; k < theSize; ++k)
		    objects[k] = rhs.objects[k];
	    }

	    //‘=’的重置，为由‘=’提供的深度复制

	    Vector & operator= ( const Vector & rhs )
	    {
		Vector copy = rhs;
		std::swap( *this, copy);
		return *this;
	    }

	    // 析构函数用于释放内存空间

	    ~Vector()
	    {
		delete [] objects;
	    }

	    //用与清空已经生成的向量变量，生成空向量

Vector(Vector && rhs) : theSize{ rhs.theSize },
		    theCapacity{ rhs.theCapacity},objects{rhs.objects}
		    {
			rhs.objects = nullptr;
			rhs.theSize = 0;
			rhs.theCapacity = 0;
		    }

		    

		    Vector & operator= (Vector && rhs)
		    {
			std::swap( theSize,rhs.theSize );
			std::swap( theCapacity, rhs.theCapacity);
			std::swap( objects, rhs.objects );
			
			return *this;
		    }
		    //设计思路为如果新的大小大于原来的容量，则需要对容量进行改变，调用reserve()函数，否则只需改变向量答案便可

		    void resize(int newSize )
		    {
			if(newSize > theCapacity)
			    reserve( newSize * 2);
			theSize = newSize;
		    }
		    //完成对容量的重置，如果新的容量小于原来的大小，则需要停止执行，
		    //若新的容量大于大小，则需要新分配连续的内存空间，然后赋值，最后利用delete[]释放掉原来的内存空间
		    void reserve( int newCapacity)
		    {
			if(newCapacity < theSize)
			    return;

			Object *newArray = new Object[ newCapacity ];
			for( int k=0; k<theSize; ++k)
			    newArray[k] = std::move( objects[k]);

			theCapacity = newCapacity;
			std::swap( objects, newArray );
			delete [] newArray;
		    }

		    //重置“[]”运算符，作用返回对应位的内容
		    
		    Object & operator[](int index)
		    {return objects[ index ];}
		    
		    //返回对应位的值，但是不能够对其修改，读出对应位置的值
		    const Object & operator[](int index) const
		    {return objects[index];}

		    //判断向量是否为空
		    bool empty() const
		    {return size()==0;}
		    //得到向量的大小，但是不能对大小有所改变
		    int size() const
		    {return theSize;}
		    //得到向量的容量大小
		    int capacity() const
		    {return theCapacity;}

		    //在向量末尾加入新的数值，如果大于原来容量，则调用reserve()
		    //对容量进行新的分配，然后直接加一即可
		    //同时因为有SPARE_CAPACITY的存在，所以push_back()函数的调用效率较高，调用reserve()函数的概率较小

		    void push_back(const Object & x)
		    {
			if(theSize==theCapacity)
			    reserve(2*theCapacity+1);
			objects[ theSize++ ] = x;
		    }

		    //与上者同理

		    void push_back(Object && x)
		    {
			if(theSize == theCapacity )
			    reserve( 2* theCapacity + 1);
			objects[ theSize++ ] = std::move( x );
		    }

		    //删除最后一位，只需要缩小向量的大小即可
		    void pop_back()
		    {
			--theSize;
		    }
		    //返回向量的最后一位
		    const Object & back() const
		    {
			return objects[theSize - 1];
			
		    }

		    //生成迭代器

		    typedef Object * iterator;
		    typedef const Object * const_iterator;

		    iterator begin()
		    {
			return &objects[0];
		    }
		    const_iterator begin() const
		    {return &objects[0];}

		    iterator end()
		    {return &objects[size()];}
		    const_iterator end() const
		    {return &objects[size()];}

		    //固定初始空余容量为十六

		    static const int SPARE_CAPACITY = 16;

private:
		    int theSize;
		    int theCapacity;
		    Object * objects;

	
};
